C++ Primer, Fifth Edition: From Structs to Abstract Data Types

The journey from a struct to an Abstract Data Type (ADT) marks the transition from a "Glass Box," where every internal wire is exposed, to a "Black Box" where the interface is separated from the implementation. This shift ensures encapsulation: users interact with functions like read or combine without needing to know how revenue is calculated or stored.

1. Class Architecture

Every class defines a unique type identity. Even if two classes share identical members, C++ treats them as incompatible. Using typedef and forward declarations (e.g., class Screen;) allows us to design complex relationships while maintaining abstraction. We often use synthesized versions of constructors, like Sales_data() = default;, to maintain the convenience of built-in types ($$total = trans;$$).

2. Nonmember Interface Functions

Functions like read are Nonmember Class-Related Functions. They are part of the interface but not the class itself, often requiring friendship to access private data.

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

What is the result of the following code?
struct First { int i; }; struct Second { int i; }; First f; Second s = f;

Success: The members are identical.

Error: obj1 and obj2 have different types.

Success: C++ allows structural typing.

Warning: members should be private.

QUESTION 2

Which keyword is used to request the compiler to generate a synthesized default constructor?

= auto

= synthesized

= default

= virtual

✅ Correct!

= default can appear with the declaration inside the class or the definition outside.

❌ Incorrect

The specific syntax introduced in C++11 is = default.

QUESTION 3

Why is the read function typically not a member of the Sales_data class?

It requires access to private members.

Member functions cannot return stream references.

IO operations are often conceptually separate from the object's core state logic.

Nonmember functions are faster.

✅ Correct!

Nonmember functions like read and print are part of the interface but kept separate to maintain logical cohesion.

QUESTION 4

What is the default access level for a class vs a struct in C++?

Both are private by default.

class: private; struct: public.

class: public; struct: private.

Both are public by default.

✅ Correct!

The only technical difference between class and struct is the default access level for members and inheritance.

❌ Incorrect

Think of struct as 'data-first' (public) and class as 'logic-first' (private).

QUESTION 5

What does a 'forward declaration' like class Screen; allow you to do?

Define the full body of the class later.

Allocate an object of type Screen immediately.

Access the private members of Screen.

Inline all Screen member functions.

Architecting the Sales_data Interface

Applying Interface/Implementation Separation

You are tasked with upgrading a legacy struct-based system to a formal ADT. You must implement the standard interface functions while strictly hiding implementation details.

1. Provide the code for Exercise 7.6: Define your own versions of the add, read, and print functions for Sales_data.

Solution:

istream &read(istream &is, Sales_data &item) { double price = 0; is >> item.bookNo >> item.units_sold >> price; item.revenue = price * item.units_sold; return is; }

ostream &print(ostream &os, const Sales_data &item) { os << item.isbn() << " " << item.units_sold << " " << item.revenue; return os; }

Sales_data add(const Sales_data &lhs, const Sales_data &rhs) { Sales_data sum = lhs; sum.combine(rhs); return sum; }

2. In your Person class (Exercise 7.19), which members should be public and which private? Explain.

Solution:
Data members like string name; and string address; should be private to prevent direct tampering. The public interface should include constructors and 'getter' functions like getName() and getAddress(). This allows the internal storage (e.g., changing string to a custom Name object) to change without breaking user code.

3. If a Screen function like set returns Screen (by value) instead of Screen& (by reference), what happens to the chain myScreen.move(4,0).set('#');?

Solution:
The move function returns a temporary copy of myScreen. The subsequent set('#') is called on this temporary copy, not the original myScreen object. Consequently, the original myScreen remains unchanged after the move.